1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <stb_dxt.h>
#include <string.h>
#include "common/alignment.h"
#include "video_core/textures/bcn.h"
#include "video_core/textures/workers.h"
namespace Tegra::Texture::BCN {
using BCNCompressor = void(u8* block_output, const u8* block_input, bool any_alpha);
template <u32 BytesPerBlock, bool ThresholdAlpha = false>
void CompressBCN(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth,
std::span<uint8_t> output, BCNCompressor f) {
constexpr u8 alpha_threshold = 128;
constexpr u32 bytes_per_px = 4;
const u32 plane_dim = width * height;
Common::ThreadWorker& workers{GetThreadWorkers()};
for (u32 z = 0; z < depth; z++) {
for (u32 y = 0; y < height; y += 4) {
auto compress_row = [z, y, width, height, plane_dim, f, data, output]() {
for (u32 x = 0; x < width; x += 4) {
// Gather 4x4 block of RGBA texels
u8 input_colors[4][4][4];
bool any_alpha = false;
for (u32 j = 0; j < 4; j++) {
for (u32 i = 0; i < 4; i++) {
const size_t coord =
(z * plane_dim + (y + j) * width + (x + i)) * bytes_per_px;
if ((x + i < width) && (y + j < height)) {
if constexpr (ThresholdAlpha) {
if (data[coord + 3] >= alpha_threshold) {
input_colors[j][i][0] = data[coord + 0];
input_colors[j][i][1] = data[coord + 1];
input_colors[j][i][2] = data[coord + 2];
input_colors[j][i][3] = 255;
} else {
any_alpha = true;
memset(input_colors[j][i], 0, bytes_per_px);
}
} else {
memcpy(input_colors[j][i], &data[coord], bytes_per_px);
}
} else {
memset(input_colors[j][i], 0, bytes_per_px);
}
}
}
const u32 bytes_per_row = BytesPerBlock * Common::DivideUp(width, 4U);
const u32 bytes_per_plane = bytes_per_row * Common::DivideUp(height, 4U);
f(output.data() + z * bytes_per_plane + (y / 4) * bytes_per_row +
(x / 4) * BytesPerBlock,
reinterpret_cast<u8*>(input_colors), any_alpha);
}
};
workers.QueueWork(std::move(compress_row));
}
workers.WaitForRequests();
}
}
void CompressBC1(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth,
std::span<uint8_t> output) {
CompressBCN<8, true>(data, width, height, depth, output,
[](u8* block_output, const u8* block_input, bool any_alpha) {
stb_compress_bc1_block(block_output, block_input, any_alpha,
STB_DXT_NORMAL);
});
}
void CompressBC3(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth,
std::span<uint8_t> output) {
CompressBCN<16, false>(data, width, height, depth, output,
[](u8* block_output, const u8* block_input, bool any_alpha) {
stb_compress_bc3_block(block_output, block_input, STB_DXT_NORMAL);
});
}
} // namespace Tegra::Texture::BCN
|
